/** The channel is closed for an unexpected reason and should automatically reopen */
const unintentionalCloseAccountScenario = test.macro({
  title: (_, chainName: string) =>
    `Automatically reopen closed channel on ${chainName}`,
  exec: async (t, chainName: string) => {
    const config = chainConfig[chainName];
    if (!config) return t.fail(`Unknown chain: ${chainName}`);

    const {
      wallets,
      provisionSmartWallet,
      vstorageClient,
      retryUntilCondition,
      useChain,
      hermes,
    } = t.context;

    const agoricAddr = wallets[chainName];
    const wdUser1 = await provisionSmartWallet(agoricAddr, {
      BLD: 100n,
      IST: 100n,
    });
    t.log(`provisioning agoric smart wallet for ${agoricAddr}`);

    const doOffer = makeDoOffer(wdUser1);
    t.log(`${chainName} makeAccount offer`);
    const offerId = `${chainName}-makeAccount-${Date.now()}`;

    await doOffer({
      id: offerId,
      invitationSpec: {
        source: 'agoricContract',
        instancePath: [contractName],
        callPipe: [['makeOrchAccountInvitation']],
      },
      offerArgs: { chainName },
      proposal: {},
    });
    const currentWalletRecord = await retryUntilCondition(
      () => vstorageClient.queryData(`published.wallet.${agoricAddr}.current`),
      ({ offerToPublicSubscriberPaths }) =>
        Object.fromEntries(offerToPublicSubscriberPaths)[offerId],
      `${offerId} continuing invitation is in vstorage`,
    );
    const offerToPublicSubscriberMap = Object.fromEntries(
      currentWalletRecord.offerToPublicSubscriberPaths,
    );

    const accountStoragePath = offerToPublicSubscriberMap[offerId]?.account;
    t.assert(accountStoragePath, 'account storage path returned');
    const address = accountStoragePath.split('.').pop();
    t.log('Got address:', address);

    const {
      remoteAddress,
      localAddress,
    }: CosmosOrchestrationAccountStorageState =
      await vstorageClient.queryData(accountStoragePath);
    const { rPortID, rChannelID } = parseRemoteAddress(remoteAddress);
    const { lPortID, lChannelID, lConnectionID } =
      parseLocalAddress(localAddress);

    const dst = {
      chainId: chainInfo['agoric'].chainId,
      channelID: lChannelID,
      portID: lPortID,
      connectionID: lConnectionID,
    };
    const src = {
      chainId: useChain(chainName).chainInfo.chain.chain_id,
      channelID: rChannelID,
      portID: rPortID,
    };
    console.log(
      `Initiating channelCloseInit for dst: ${JSON.stringify(dst)} src: ${JSON.stringify(src)}`,
    );
    const closeChannelTx = hermes.channelCloseInit(chainName, dst, src);
    console.log('closeChannelExec', closeChannelTx);

    const remoteQueryClient = makeQueryClient(
      await useChain(chainName).getRestEndpoint(),
    );
    const { channel } = await retryUntilCondition(
      () => remoteQueryClient.queryChannel(rPortID, rChannelID),
      // @ts-expect-error ChannelSDKType.state is a string not a number
      ({ channel }) => channel?.state === 'STATE_CLOSED',
      'ICA channel closed from Hermes closeChannelInit',
      {
        retryIntervalMs: 300,
        maxRetries: 10,
      },
    );
    t.is(
      channel?.state,
      // @ts-expect-error ChannelSDKType.state is a string not a number
      'STATE_CLOSED',
      'closed state is observed',
    );

    const { channels } = await retryUntilCondition(
      () => remoteQueryClient.queryChannels(),
      // @ts-expect-error ChannelSDKType.state is a string not a number
      ({ channels }) => findNewChannel(channels, { rPortID, lPortID }),
      `ICA channel is reopened on ${chainName} Host`,
    );
    const newChannel = findNewChannel(channels, { rPortID, lPortID });
    t.log('New Channel after Reopen', newChannel);
    if (!newChannel) throw new Error('Channel not found');
    const newAddress = JSON.parse(newChannel.version).address;
    t.is(newAddress, address, `same chain address is returned - ${chainName}`);
    t.is(
      newChannel.state,
      // @ts-expect-error ChannelSDKType.state is a string not a number
      'STATE_OPEN',
      `channel is open on ${chainName} Host`,
    );
    t.not(newChannel.channel_id, rChannelID, 'remote channel id changed');
    t.not(
      newChannel.counterparty.channel_id,
      lChannelID,
      'local channel id changed',
    );
  },
});

test.serial(unintentionalCloseAccountScenario, 'cosmoshub');
test.serial(unintentionalCloseAccountScenario, 'osmosis');